home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / progut~1 / iostream.zoo / include / streambu.h < prev    next >
Encoding:
C/C++ Source or Header  |  1991-09-22  |  10.8 KB  |  360 lines
  1. //    This is part of the iostream library, providing input/output for C++.
  2. //    Copyright (C) 1991 Per Bothner.
  3. //
  4. //    This library is free software; you can redistribute it and/or
  5. //    modify it under the terms of the GNU Library General Public
  6. //    License as published by the Free Software Foundation; either
  7. //    version 2 of the License, or (at your option) any later version.
  8. //
  9. //    This library is distributed in the hope that it will be useful,
  10. //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12. //    Library General Public License for more details.
  13. //
  14. //    You should have received a copy of the GNU Library General Public
  15. //    License along with this library; if not, write to the Free
  16. //    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  17.  
  18. #ifndef _STREAMBUF_H
  19. #define _STREAMBUF_H
  20. #ifdef __GNUG__
  21. #pragma interface
  22. #endif
  23.  
  24. #ifndef atarist
  25. /* KLUDGES!! */
  26. #ifndef size_t
  27. #define size_t unsigned long
  28. #endif
  29. #ifndef fpos_t    /* this is a very questionable define */
  30. #define fpos_t long
  31. #endif
  32.  
  33. #ifndef EOF
  34. #define EOF (-1)
  35. #endif
  36. #ifndef NULL
  37. #define NULL ((void*)0)
  38. #endif
  39. #ifndef BUFSIZ
  40. #define BUFSIZ 1024
  41. #endif
  42.  
  43. #else /* atari */
  44.  
  45. #include <stddef.h>
  46. #include <stdio.h>
  47. extern "C" unsigned long __DEFAULT_BUFSIZ__;
  48. #endif
  49.  
  50. class ostream; class streambuf;
  51. extern streambuf* __stream_list; /* List of open FILEs. */
  52.  
  53. typedef long streamoff, streampos;
  54.  
  55. class ios
  56. {
  57.   public:
  58.     enum io_state { goodbit=0, eofbit=1, failbit=2, badbit=4 };
  59.     enum open_mode {
  60.     in=1,        // on the atari the default bin/text mode
  61.     out=2,        // for these are set from default mode
  62.     ate=4,
  63.     app=8,
  64.     trunc=16,
  65.     nocreate=32,
  66.     noreplace=64
  67. #ifdef atarist
  68.         ,
  69.     in_bin=1|128,    // force bin mode regardless of default mode
  70.         out_bin=2|128,
  71.         app_bin=8|128,
  72.  
  73.         in_text=1|256,    // force text mode
  74.     out_text=2|256,
  75.         app_text=8|256
  76. #endif
  77.         };
  78.     enum seek_dir { beg, cur, end};
  79.     enum { skipws=01, left=02, right=04, internal=010,
  80.        dec=020, oct=040, hex=0100,
  81.        showbase=0200, showpoint=0400, uppercase=01000, showpos=02000,
  82.        scientific=04000, fixed=0100000, unitbuf=020000, stdio=040000,
  83.        dont_close=0x80000000 //Don't close streambuf when destroying stream
  84.        };
  85.     streambuf *_strbuf;
  86.     char _fill;
  87.     unsigned char _state;
  88.     unsigned short _precision;
  89.     long _width;
  90.     unsigned long _flags;
  91.     ostream* _tie;
  92.     ostream* tie() { return _tie; }
  93.     ostream* tie(ostream* val) { ostream* save=_tie; _tie=val; return save; }
  94.  
  95.     // Methods to change the format state.
  96.     char fill() { return _fill; }
  97.     char fill(char newf) { char oldf = _fill; _fill = newf; return oldf; }
  98.     unsigned long flags() { return _flags; }
  99.     unsigned long flags(unsigned long new_val) {
  100.     unsigned long old_val = _flags; _flags = new_val; return old_val; }
  101.     unsigned short precision() { return _precision; }
  102.     unsigned short precision(int newp) {
  103.     unsigned short oldp = _precision; _precision = (unsigned short)newp;
  104.     return oldp; }
  105.     unsigned long setf(unsigned long mask) {
  106.     unsigned long oldbits = _flags & mask;
  107.     _flags |= _flags; return oldbits; }
  108.     unsigned long setf(unsigned long val, unsigned long mask) {
  109.     unsigned long oldbits = _flags & mask;
  110.     _flags &= ~mask; _flags |= val&mask; return oldbits; }
  111.     unsigned long unsetf(unsigned long mask) {
  112.     unsigned long oldbits = _flags & mask;
  113.     _flags &= ~mask; return oldbits; }
  114.     long width() { return _width; }
  115.     long width(long val) { long save = _width; _width = val; return save; }
  116.  
  117.     static const unsigned long basefield;
  118.     static const unsigned long adjustfield;
  119.     static const unsigned long floatfield;
  120.  
  121.     streambuf* rdbuf() { return _strbuf; }
  122.     void clear(int state = 0) { _state = state; }
  123.     int good() { return _state == 0; }
  124.     int eof() { return _state & ios::eofbit; }
  125.     int fail() { return _state & (ios::badbit|ios::failbit); }
  126.     int bad() { return _state & ios::badbit; }
  127.     int rdstate() { return _state; }
  128.     operator void*() { return fail() ? (void*)0 : (void*)this; }
  129.     int operator!() { return fail(); }
  130.     int is_open();
  131.     int readable();
  132.     int writable();
  133.  
  134.   protected:
  135.     ios(streambuf*sb) { _strbuf=sb; _state=0; _width=0; _fill=' ';
  136.             _flags=ios::skipws; _precision=6; }
  137. };
  138.  
  139. // Magic numbers and bits for the _flags field.
  140. // The magic numbers use the high-order bits of _flags;
  141. // the remaining bits are abailable for variable flags.
  142. // Note: The magic numbers must all be negative ...
  143.  
  144. #define _IO_MAGIC 0xFBAD0000 /* Magic number */
  145. #define _OLD_STDIO_MAGIC 0xFABC0000 /* Emulate old stdio. */
  146. #define _IO_MAGIC_MASK 0xFFFF0000
  147. #define _S_USER_BUF 1 /* User owns buffer; don't delete it on close. */
  148. #define _S_UNBUFFERED 2
  149. #define _S_CAN_READ 4
  150. #define _S_CAN_WRITE 8
  151. #define _S_EOF_SEEN 16
  152. #define _S_ERR_SEEN 32
  153. #define _S_DELETE_DONT_CLOSE 64
  154. #ifdef atarist
  155. #define _S_IS_BINARY 128    // stream is binary/text
  156. #endif
  157. #define _S_LINE_BUF 0x4000
  158. #define _S_IS_FILEBUF 0x8000
  159.  
  160. struct __streambuf {
  161.     // NOTE: If this is changed, also change __FILE in stdio.h!
  162.     unsigned long _flags;/* High-order word is _IO_MAGIC; rest is flags. */
  163.     char* _gptr;    /* Current get pointer */
  164.     char* _egptr;    /* End of get area. */
  165.     char* _eback;    /* Start of putback+get area. */
  166.     char* _pbase;    /* Start of put area. */
  167.     char* _pptr;    /* Current put pointer. */
  168.     char* _epptr;    /* End of put area. */
  169.     char* _base;    /* Start of reserve area. */
  170.     char* _ebuf;    /* End of reserve area. */
  171.     struct streambuf *_chain;
  172. };
  173.  
  174. struct streambuf : private __streambuf {
  175.   protected:
  176.     char* gptr() const { return _gptr; }
  177.     char* pptr() const { return _pptr; }
  178.     char* egptr() const { return _egptr; }
  179.     char* epptr() const { return _epptr; }
  180.     char* pbase() const { return _pbase; }
  181.     char* eback() const { return _eback; }
  182.     char* ebuf() const { return _ebuf; }
  183.     char* base() const { return _base; }
  184. #ifdef atarist
  185.     int  is_binary() { return _flags & _S_IS_BINARY ? 1 : 0; }
  186.     void set_binary() { _flags |= _S_IS_BINARY; }
  187. #endif
  188.     void gbump(int n) { _gptr += n; }
  189.     void pbump(int n) { _pptr += n; }
  190.     void setb(char* b, char* eb, int a=0);
  191.     void setp(char* p, char* ep) { _pbase=_pptr=p; _epptr=ep; }
  192.     void setg(char* eb, char* g, char *eg) { _eback=eb; _gptr=g; _egptr=eg; }
  193.   public:
  194.     virtual int underflow(); // Leave public for now
  195.     virtual int overflow(int c = EOF); // Leave public for now
  196.     virtual int doallocate();
  197.     virtual streamoff seekoff(streamoff, seek_dir, int mode=ios::in|ios::out);
  198.     virtual streamoff seekpos(streampos pos, int mode = ios::in|ios::out);
  199. //    extern "C" friend int __underflow(FILE*);
  200. //    extern "C" friend int __overflow(FILE*, int);
  201.     int sputbackc(char c);
  202.     streambuf();
  203.     virtual ~streambuf();
  204. //    int handle_overflow(int c = EOF); // Used by fflush().
  205.     int unbuffered() { return _flags & _S_UNBUFFERED ? 1 : 0; }
  206.     int linebuffered() { return _flags & _S_LINE_BUF ? 1 : 0; }
  207.     void unbuffered(int i)
  208.     { if (i) _flags |= _S_UNBUFFERED; else _flags &= ~_S_UNBUFFERED; }
  209.     void linebuffered(int i)
  210.     { if (i) _flags |= _S_LINE_BUF; else _flags &= ~_S_LINE_BUF; }
  211.     int allocate() {
  212.     if (base() || unbuffered()) return 0;
  213.     else return doallocate(); }
  214.     virtual int sync();
  215.     virtual int pbackfail(int c);
  216.     virtual streambuf* setbuf(char* p, size_t len);
  217.     int in_avail() { return _egptr - _gptr; }
  218.     int out_waiting() { return _pptr - _pbase; }
  219.     size_t sputn(const char* s, size_t n);
  220.     size_t sgetn(char* s, size_t n);
  221.     long sgetline(char* buf, size_t n, char delim, int putback_delim);
  222.     int sbumpc() {
  223.     if (_gptr >= _egptr && underflow() == EOF) return EOF;
  224.     else
  225. #ifndef atarist
  226.         return *(unsigned char*)_gptr++;
  227. #else
  228.         {
  229.         int ch = *(unsigned char*)_gptr++;
  230.         if((!is_binary()) && (ch == '\r'))
  231.         return sbumpc();
  232.         return ch;
  233.     }
  234. #endif
  235.     }
  236.     
  237.     int snextc() {
  238.     if (++_gptr >= _egptr && underflow() == EOF) return EOF;
  239.     else
  240. #ifndef atarist
  241.         return *(unsigned char*)_gptr;
  242. #else
  243.         {
  244.             int ch = *(unsigned char *)_gptr;
  245.         if((!is_binary()) && (ch == '\r'))
  246.         return snextc();
  247.         return ch;
  248.     }
  249. #endif
  250.      }
  251.        
  252.     int sgetc() {
  253.     if (_gptr >= _egptr && underflow() == EOF) return EOF;
  254.     else
  255. #ifndef atarist
  256.         return *(unsigned char*)_gptr;
  257. #else
  258.         {
  259.         int ch = *(unsigned char *)_gptr;
  260.         if((!is_binary()) && (ch == '\r'))
  261.         return snextc();
  262.         return ch;
  263.     }
  264. #endif    
  265.     }
  266.  
  267. #ifdef atarist
  268.     int _atari_putc(int c) {
  269.     if ((!is_binary()) && ((c == '\n') || (c == '\r')))
  270.     {
  271.         if(c == '\r')
  272.         return (int)c;
  273.         if (_pptr >= _epptr)
  274.         {
  275.         if(overflow((int)'\r') == EOF) return EOF;
  276.         }
  277.         else
  278.         *_pptr++ = '\r';
  279.     }
  280.     if (_pptr >= _epptr) return overflow(c);
  281.     return *_pptr++ = c, (unsigned char)c;
  282.     }
  283. #endif
  284.  
  285.     int sputc(int c) {
  286. #ifndef atarist
  287.     if (_pptr >= _epptr) return overflow(c);
  288.     return *_pptr++ = c, (unsigned char)c;
  289. #else
  290.     return _atari_putc(c);
  291. #endif    
  292.     }
  293. };
  294.  
  295. struct __file_fields {
  296. #ifdef LITTLE_ENDIAN
  297.     char _fake;
  298.     char _shortbuf[1];
  299.     short _fileno;
  300. #else
  301.     short _fileno;
  302.     char _shortbuf[1];
  303.     char _fake;
  304. #endif
  305.     int _blksize;
  306.     char* _save_gptr;
  307.     char* _save_egptr;
  308. #ifndef atarist
  309.     fpos_t _offset;
  310. #else
  311.     long _offset;
  312. #endif
  313. };
  314.  
  315. class filebuf : public streambuf {
  316.     struct __file_fields _fb;
  317.     void init();
  318.   public:
  319.     filebuf();
  320.     filebuf(int fd);
  321.     filebuf(int fd, char* p, size_t len);
  322.     ~filebuf();
  323.     filebuf* attach(int fd);
  324.     filebuf* open(const char *filename, const char *mode);
  325.     filebuf* open(const char *filename, int mode, int prot = 0664);
  326.     virtual int underflow();
  327.     virtual int overflow(int c = EOF);
  328.     int is_open() { return _fb._fileno >= 0; }
  329.     int fd() { return is_open() ? _fb._fileno : EOF; }
  330.     filebuf* close();
  331.     virtual int doallocate();
  332.     virtual streamoff seekoff(streamoff, seek_dir, int mode=ios::in|ios::out);
  333.   protected: // See documentation in filebuf.C.
  334.     virtual int pbackfail(int c);
  335.     virtual int sync();
  336.     int is_reading() { return eback() != egptr(); }
  337.     int is_writing() { return pbase() != NULL; }
  338.     char* cur_ptr() { return is_reading() ?  gptr() : pptr(); }
  339.     /* System's idea of pointer */
  340.     char* file_ptr() { return _fb._save_gptr ? _fb._save_egptr : egptr(); }
  341.     int do_flush();
  342.     // Low-level operations (Usually invoke system calls.)
  343. #ifndef atarist
  344.     virtual int sys_read(char* buf, size_t size);
  345.     virtual fpos_t sys_seek(fpos_t, seek_dir);
  346. #else
  347.     virtual long sys_read(char* buf, size_t size);
  348.     virtual long sys_seek(long, seek_dir);
  349. #endif
  350.     virtual long sys_write(const void*, long);
  351.     virtual int sys_stat(void*); // Actually, a (struct stat*)
  352.     virtual int sys_close();
  353. };
  354.  
  355. inline int ios::readable() { return rdbuf()->_flags & _S_CAN_READ; }
  356. inline int ios::writable() { return rdbuf()->_flags & _S_CAN_WRITE; }
  357. inline int ios::is_open() {return rdbuf()->_flags & _S_CAN_READ+_S_CAN_WRITE;}
  358.  
  359. #endif _STREAMBUF_H
  360.